Apa perbedaan antara `let` dan` var` di swift?

Apa perbedaan antara letdan vardalam bahasa Swift Apple?

Dalam pemahaman saya, ini adalah bahasa yang dikompilasi tetapi tidak memeriksa jenis pada waktu kompilasi. Itu membuat saya bingung. Bagaimana kompiler mengetahui tentang kesalahan tipe? Jika kompiler tidak memeriksa jenisnya, bukankah itu masalah dengan lingkungan produksi?

Kata letkunci mendefinisikan konstanta:

let theAnswer = 42

Tidak theAnswerdapat diubah setelahnya. Inilah sebabnya mengapa apa pun weaktidak dapat ditulis menggunakan let. Mereka perlu berubah selama runtime dan Anda harus menggunakan varsebagai gantinya.

The varmendefinisikan variabel biasa.

Apa yang menarik:

Nilai konstanta tidak perlu diketahui pada waktu kompilasi , tetapi Anda harus menetapkan nilai tepat sekali.

Fitur aneh lainnya:

Anda dapat menggunakan hampir semua karakter yang Anda suka untuk nama konstan dan variabel, termasuk karakter Unicode:

let 🐶🐮 = "dogcow"

Kutipan Dari: Apple Inc. “Bahasa Pemrograman Swift.” iBooks. https://itunes.apple.com/WebObjects/MZStore.woa/wa/viewBook?id=881256329

EDIT

Karena komentar meminta untuk menambahkan fakta lain ke jawabannya, mengubahnya menjadi jawaban wiki komunitas . Merasa bebas mengedit jawaban untuk membuatnya lebih baik.

Menurut Buku Bahasa Pemrograman Swift

Seperti C, Swift menggunakan variabel untuk menyimpan dan merujuk nilai dengan nama pengenal. Swift juga menggunakan banyak variabel yang nilainya tidak dapat diubah. Ini dikenal sebagai konstanta, dan jauh lebih kuat daripada konstanta dalam C.

Keduanya vardan letmerupakan referensi , oleh karena itu letmerupakan referensi const . Menggunakan tipe fundamental tidak benar-benar menunjukkan letperbedaannya const. Perbedaannya muncul ketika menggunakannya dengan instance kelas (tipe referensi):

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"

letdigunakan untuk mendefinisikan konstanta dan varuntuk mendefinisikan variabel.

Mungkin lebih baik untuk menyatakan perbedaan ini dengan gagasan Mutability / Unmutability yang merupakan paradigma yang benar dari nilai-nilai dan contoh perubahan dalam ruang Objek yang lebih besar dari satu-satunya pengertian "konstan / variabel" biasa. Dan lebih jauh ini lebih dekat dengan pendekatan Objective C.

2 tipe data: tipe nilai dan tipe referensi.

Dalam konteks Jenis Nilai:

'let' mendefinisikan nilai konstan (tidak dapat dicapai). 'var' mendefinisikan nilai yang dapat diubah (bisa diubah).

let aInt = 1   //< aInt is not changeable

var aInt = 1   //< aInt can be changed

Dalam konteks Jenis Referensi:

Label suatu data bukanlah nilai melainkan referensi ke suatu nilai.

if aPerson = Orang (nama: Foo, pertama: Bar)

aPerson tidak mengandung Data orang ini tetapi referensi ke data Orang ini.

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)

Itu

Mendeklarasikan Konstanta dan Variabel bagian dari dokumentasi Bahasa Swift Programming menentukan hal-hal berikut:

Anda mendeklarasikan konstanta dengan kata kunci let dan variabel dengan kata kunci var.

Pastikan Anda memahami cara kerjanya untuk tipe Referensi. Tidak seperti Jenis Nilai, properti yang mendasari objek dapat berubah meskipun turunan jenis referensi dinyatakan sebagai konstanta. Lihat bagian Kelas adalah Jenis Referensi dari dokumentasi, dan lihat contoh di mana mereka mengubah properti frameRate.

Sangat sederhana:

• let konstan.
• var dinamis.

Sedikit deskripsi:

letmenciptakan konstanta. (semacam an NSString). Anda tidak dapat mengubah nilainya setelah Anda menetapkannya. Anda masih dapat menambahkannya ke hal lain dan membuat variabel baru.

varmenciptakan variabel. (semacam suka NSMutableString) sehingga Anda dapat mengubah nilai itu. Tetapi ini sudah dijawab beberapa kali.

letmendefinisikan "konstan". Nilainya diatur sekali dan hanya sekali, meskipun tidak harus ketika Anda mendeklarasikannya. Misalnya, Anda menggunakan letuntuk mendefinisikan properti di kelas yang harus ditetapkan selama inisialisasi:

class Person {

    let firstName: String
    let lastName: String

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

Dengan pengaturan ini, tidak sah untuk menetapkan firstNameatau lastNamesetelah memanggil (mis.) Person(first:"Malcolm", last:"Reynolds")Untuk membuat aPerson instance.

Anda harus menentukan tipe untuk semua variabel ( letatau var) pada waktu kompilasi, dan kode apa pun yang mencoba mengatur variabel hanya dapat menggunakan tipe itu (atau subtipe). Anda dapat menetapkan nilai pada waktu berjalan, tetapi jenisnya harus diketahui pada waktu kompilasi.

let- constant
var-variable

[Konstan vs variabel]
[Struct vs Class]

Doc .swift.org resmi mengatakan

Nilai a constanttidak dapat diubah setelah diatur, sedangkan a variabledapat diatur ke nilai yang berbeda di masa mendatang.

Terminologi ini sebenarnya menggambarkan mekanisme penugasan kembali

Mutabilitas - dapat diubah - status objek dapat diubah setelah pembuatan

Nilai dan Jenis Referensi ^[Tentang]

Nilai (Struct, Enum)

Swift's structdapat mengubah status mutabilitas mereka:

let+ struct= immutable= Konstan nilai
Hal ini dapat tidak akan ditugaskan kembali atau diubah

var+ struct= mutable
Ini dapat dipindahkan atau diubah

Tipe Referensi (Kelas)

Swift classesadalah mutablea-priorat

let+ class= konstanta alamat
Ini tidak dapat dipindahkan dan dapat diubah

var+ class
Ini dapat dipindahkan atau diubah

//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 - Mutasi Fungsi Struct

Anda dapat menandai metode struct sebagaimutating

1. Menunjukkan bahwa fungsi ini mengubah nilai properti internal.
2. Hanya bisa digunakan di 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 Memodifikasi struct di dalam suatu fungsi

Anda dapat menandai parameter fungsi (yang merupakan struct) sebagai inout

Karena structtipe nilai, itu dilewatkan oleh nilai sebagai fungsi hasil akan mengambil salinan. Jika Anda menandai structsebagai inoutparameter, artinya parameter ini menjadi vardan Anda dapat mengubah status structdan perubahan ini akan terlihat di luar lingkup fungsi

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

Gunakan letkapan pun Anda bisa. Gunakan varsaat Anda harus.

Satu lagi perbedaan, yang saya temui dalam bahasa lain untuk Konstanta adalah: tidak dapat menginisialisasi konstanta (biarkan) untuk nanti , harus diinisialisasi ketika Anda akan mendeklarasikan konstanta.

Misalnya :

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

Variabel

var variableValue : Int // No issues 

letdigunakan untuk mendeklarasikan nilai konstan - Anda tidak akan mengubahnya setelah memberinya nilai awal.
vardigunakan untuk mendeklarasikan nilai variabel - Anda dapat mengubah nilainya sesuai keinginan.

let digunakan untuk mendefinisikan konstanta dan var untuk mendefinisikan variabel. Anda mendefinisikan string menggunakan var maka String tertentu dapat dimodifikasi (atau bermutasi) dengan menetapkannya ke variabel (dalam hal ini dapat dimodifikasi), dan jika Anda mendefinisikan string menggunakan let konstannya (dalam hal ini tidak dapat diubah):

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

biarkan kata kunci mendefinisikan sebuah konstanta

let myNum = 7

jadi myNum tidak bisa diubah setelahnya;

Tetapi var mendefinisikan variabel biasa.

Nilai konstanta tidak perlu diketahui pada waktu kompilasi, tetapi Anda harus memberinya nilai tepat sekali.

Anda dapat menggunakan hampir semua karakter yang Anda suka untuk nama konstan dan variabel, termasuk karakter Unicode;

misalnya

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

Tetapi jika kita ambil biarkan ...

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

Seperti Luc-Oliver, NullData, dan beberapa orang lain katakan di sini, letmendefinisikan data yang tidak dapat diubah sementara varmendefinisikan data yang dapat diubah. Apa pun funcyang dapat dipanggil pada variabel yang ditandai mutatinghanya dapat dipanggil jika itu adalah varvariabel (kompiler akan melempar kesalahan). Ini juga berlaku untuk funcyang menerima inoutvariabel.

Namun, letdan varjuga berarti bahwa variabel tidak dapat dipindahkan. Ini memiliki dua makna, keduanya dengan tujuan yang sangat mirip

nilai var dapat diubah, setelah diinisialisasi. Tapi biarkan nilai tidak diubah, ketika itu dimasukkan sekali.

Dalam hal var

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

Dalam kasus let

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

Kata kunci var digunakan untuk mendefinisikan variabel yang nilainya dapat Anda ubah dengan mudah seperti ini:

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

Namun, kata kunci let hanya untuk membuat konstanta yang digunakan ketika Anda tidak ingin mengubah nilai konstanta lagi. Jika Anda mencoba mengubah nilai konstanta, Anda akan mendapatkan kesalahan:

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

Membiarkan adalah variabel abadi, yang berarti bahwa itu tidak dapat diubah, bahasa lain menyebutnya konstan. Dalam C ++ Anda dapat mendefinisikannya sebagai const.

Var adalah variabel yang dapat berubah, yang berarti dapat diubah. Di C ++ (pembaruan versi 2011), ini sama dengan menggunakan otomatis, meskipun swift memungkinkan lebih banyak fleksibilitas dalam penggunaan. Ini adalah tipe variabel yang lebih terkenal untuk pemula.

biarkan adalah nilai konstan, jadi itu tidak pernah bisa diubah.

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

Var adalah variabel, dan dapat berubah (tetapi setelah itu didefinisikan bukan tipe data yang berbeda.)

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

Jika Anda mencoba mengubah variabel ke tipe data yang berbeda, itu tidak akan berfungsi

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

Perbedaan utama adalah bahwa varnilai variabel dapat berubah, dan lettidak bisa. Jika Anda ingin memiliki data input pengguna, Anda akan menggunakan varsehingga nilainya dapat diubah dan menggunakan letvariabel tipe data sehingga nilainya tidak dapat diubah.

var str      = "dog"  // str value is "dog"
str          = "cat"  // str value is now "cat"

let strAnimal = "dog" // strAnimal value is "dog"
strAnimal     = "cat" // Error !

Nilai dapat dipindahkan jika ada var

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

** konstanta newAge tidak dapat dipindahkan ke nilai baru. Mencoba melakukannya akan memberikan kesalahan waktu kompilasi **

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

"Gunakan biarkan untuk membuat konstanta dan var untuk membuat variabel"

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

var adalah variabel yang dapat diubah sebanyak yang Anda inginkan dan kapan saja

sebagai contoh

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

membiarkan adalah konstan yang tidak dapat diubah

sebagai contoh

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

Meskipun Anda sudah mendapatkan banyak perbedaan antara let dan var tetapi satu perbedaan utama adalah:

let is compiled fast in comparison to var.

Setiap orang telah menjawab ini, tetapi inilah cara Anda dapat mengingat apa itu

Biarkan akan selalu mengatakan pemikiran yang sama tentang "biarkan" seperti membiarkan ini bekerja untuk sekali dan selalu untuk variabel "var" selalu dapat berubah maka mereka disebut variabel

varadalah satu-satunya cara untuk membuat variabel dengan cepat. vartidak berarti variabel dinamis seperti dalam kasus bahasa yang ditafsirkan seperti javascript. Sebagai contoh,

var name = "Bob"

Dalam hal ini, tipe variabel namedisimpulkan bahwa nama adalah tipe String, kita juga dapat membuat variabel dengan tipe yang secara eksplisit mendefinisikan, misalnya

var age:Int = 20

Sekarang jika Anda menetapkan string ke umur, maka kompiler memberikan kesalahan.

letdigunakan untuk mendeklarasikan konstanta. Sebagai contoh

let city = "Kathmandu"

Atau bisa juga kita lakukan,

let city:String = "Kathmandu"

Jika Anda mencoba mengubah nilai kota, itu memberikan kesalahan pada waktu kompilasi.

let digunakan untuk konstanta yang tidak dapat dimodifikasi sementara var adalah variabel biasa

Contoh:

beri nama = "Bob" Sesuatu seperti nama = "Jim" akan menampilkan kesalahan karena konstanta tidak dapat dimodifikasi.

PERBEDAAN SEDERHANA

let = (tidak bisa diubah)

var = (pembaruan setiap saat)

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

Ketika Anda mendeklarasikan variabel dengan var, itu berarti ia dapat diperbarui, itu variabel, nilainya dapat diubah.

Ketika Anda mendeklarasikan variabel dengan let, itu berarti ia tidak dapat diperbarui, itu adalah variabel, nilainya tidak dapat dimodifikasi.

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"

Mari kita pahami contoh di atas: Kami telah membuat variabel baru "a" dengan "var keyword" dan menetapkan nilai "1". Ketika saya mencetak "a" saya mendapatkan output sebagai 1. Kemudian saya menetapkan 2 ke "var a" yaitu saya mengubah nilai variabel "a". Saya bisa melakukannya tanpa mendapatkan kesalahan kompiler karena saya menyatakannya sebagai var.

Dalam skenario kedua saya membuat variabel baru "b" dengan "biarkan kata kunci" dan menetapkan nilai "4". Ketika saya mencetak "b" saya mendapat 4 sebagai output. Kemudian saya mencoba untuk menetapkan 5 ke "let b" yaitu saya mencoba untuk memodifikasi variabel "let" dan saya mendapatkan kesalahan waktu kompilasi "Tidak dapat menetapkan nilai: 'b' adalah konstanta 'biarkan'".

Meskipun saat ini saya masih membaca manual, tapi saya pikir ini sangat dekat dengan constpointer C / C ++ . Dengan kata lain, sesuatu seperti perbedaan antara char const*dan char*. Compiler juga menolak untuk memperbarui konten, tidak hanya referensi penugasan kembali (pointer).

Sebagai contoh, katakanlah Anda memiliki struct ini. Berhati-hatilah karena ini adalah struct, bukan kelas. AFAIK, kelas tidak memiliki konsep negara abadi.

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

Karena struct tidak dapat diubah secara default, Anda harus menandai metode mutator dengannya mutating. Dan karena namanya aaa1konstan, Anda tidak dapat memanggil metode mutator di dalamnya. Inilah yang kami harapkan pada pointer C / C ++.

Saya percaya ini adalah mekanisme untuk mendukung semacam hal yang benar-benar benar .

Nyatakan konstanta dengan kata kunci let dan variabel dengan kata kunci var.

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

Deklarasikan beberapa konstanta atau banyak variabel pada satu baris, dipisahkan dengan koma:

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

Mencetak Konstanta dan Variabel

Anda dapat mencetak nilai konstanta atau variabel saat ini dengan fungsi println:

println(friendlyWelcome)

Swift menggunakan interpolasi string untuk memasukkan nama konstanta atau variabel sebagai pengganti di string yang lebih panjang

Bungkus nama dalam tanda kurung dan lepas dengan backslash sebelum tanda kurung buka:

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

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

Ditemukan jawaban yang bagus semoga bisa membantu :)