Jaka jest różnica między „let” i „var” w trybie szybkim?

Jaka jest różnica między leti varw języku Apple Swift?

W moim rozumieniu jest to język skompilowany, ale nie sprawdza on typu w czasie kompilacji. To mnie dezorientuje. Skąd kompilator wie o błędzie typu? Jeśli kompilator nie sprawdza typu, czy nie jest to problem ze środowiskiem produkcyjnym?

letKluczowe definiuje stały:

let theAnswer = 42

Nie theAnswermożna później zmienić. Dlatego nic weaknie można napisać przy użyciu let. Muszą się zmienić w czasie wykonywania i musisz ich używać var.

varDefiniuje zmienną zwykłych.

Co ciekawe:

Wartość stałej nie musi być znana w czasie kompilacji , ale musisz przypisać tę wartość dokładnie raz.

Kolejna dziwna funkcja:

Możesz używać prawie dowolnego znaku, który ci się podoba, dla nazw stałych i zmiennych, w tym znaków Unicode:

let 🐶🐮 = "dogcow"

Fragmenty: Apple Inc. „Swift Programming Language”. iBooks. https://itunes.apple.com/WebObjects/MZStore.woa/wa/viewBook?id=881256329

EDYTOWAĆ

Ponieważ komentarze z prośbą o dodanie innych faktów do odpowiedzi, konwersja do odpowiedzi społeczności wiki . Edytuj odpowiedź, aby była lepsza.

Według The Swift Programming Language Book

Podobnie jak C, Swift używa zmiennych do przechowywania i odwoływania się do wartości za pomocą nazwy identyfikującej. Swift również szeroko wykorzystuje zmienne, których wartości nie można zmienić. Są one znane jako stałe i są znacznie potężniejsze niż stałe w C.

Oba vari letsą odniesieniami , dlatego letjest stałym odniesieniem . Używanie podstawowych typów tak naprawdę nie pokazuje, czym letsię różni const. Różnica pojawia się podczas korzystania z instancji klasy (typy referencyjne):

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"

letsłuży do definiowania stałych i vardefiniowania zmiennych.

Być może lepiej jest określić tę różnicę za pomocą pojęcia Mutability / Unmutability, który jest prawidłowym paradygmatem zmienności wartości i instancji w przestrzeni Objects, która jest większa niż jedyne zwykłe pojęcia „stała / zmienna”. Co więcej, jest to bliższe podejściu do celu C.

2 typy danych: typ wartości i typ odniesienia.

W kontekście typów wartości:

„let” określa stałą wartość (nieokiełznaną). „var” definiuje wartość zmienną (zmienną).

let aInt = 1   //< aInt is not changeable

var aInt = 1   //< aInt can be changed

W kontekście typów referencyjnych:

Etykieta danych nie jest wartością, ale odniesieniem do wartości.

jeśli aPerson = Osoba (imię: Foo, najpierw: Bar)

Osoba nie zawiera danych tej osoby, ale odniesienie do danych tej osoby.

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

Sekcja Deklarowanie stałych i zmiennych w dokumentacji Swift Programming Language określa:

Deklarujesz stałe za pomocą słowa kluczowego let, a zmienne za pomocą słowa kluczowego var.

Upewnij się, że rozumiesz, jak to działa w przypadku typów referencyjnych. W przeciwieństwie do typów wartości, podstawowe właściwości obiektu mogą ulec zmianie pomimo wystąpienia deklaracji typu odwołania jako stałej. Zobacz sekcję Klasy są typami referencyjnymi w dokumentacji i spójrz na przykład, w którym zmieniają właściwość frameRate.

Bardzo prosta:

• let jest stały.
• var jest dynamiczny.

Trochę opisu:

lettworzy stałą. (trochę jak NSString). Nie możesz zmienić jego wartości po jej ustawieniu. Nadal możesz go dodawać do innych rzeczy i tworzyć nowe zmienne.

vartworzy zmienną. (coś w stylu NSMutableString), abyś mógł zmienić jego wartość. Ale na to kilka razy odpowiedziano.

letdefiniuje „stałą”. Jego wartość jest ustawiana raz i tylko raz, choć niekoniecznie podczas jej deklarowania. Na przykład można użyć letdo zdefiniowania właściwości w klasie, którą należy ustawić podczas inicjalizacji:

class Person {

    let firstName: String
    let lastName: String

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

Przy tej konfiguracji przypisanie do firstNamelub lastNamepo wywołaniu (np.) W Person(first:"Malcolm", last:"Reynolds")celu utworzenia Personinstancji jest nieprawidłowe .

Państwo musi określić typ dla wszystkich zmiennych ( letlub var) w czasie kompilacji, a każdy kod, który próbuje ustawić zmienną może używać tego typu (lub podtyp). Możesz przypisać wartość w czasie wykonywania, ale jej typ musi być znany w czasie kompilacji.

let- constant
var-variable

[Stała vs zmienna]
[Strukt vs klasa]

Oficjalny dokument docs.swift.org mówi

Wartość parametru constantnie można zmienić po jego ustawieniu, natomiast wartość parametru a variablemożna ustawić na inną wartość w przyszłości.

Ta terminologia faktycznie opisuje mechanizm zmiany przypisania

Zmienność - zmienna - stan obiektu można zmienić po utworzeniu

Wartość i typ odniesienia ^[Informacje]

Wartość (struktura, wyliczenie)

Swift structmoże zmienić swój status zmienności:

let+ struct= immutable= Stała wartość
To może nie być przeniesiona lub zmieniona

var+ struct= mutable
Można go ponownie przypisać lub zmienić

Typ odniesienia (klasa)

Szybkie classessą mutablea-priory

let+ class= Stała adresu
To może nie być przeniesiony i może być zmieniona

var+ class
Można go ponownie przypisać lub zmienić

//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 - Funkcje mutujące struktury

Możesz oznaczyć metodę struct jakomutating

1. Wskazuje, że ta funkcja zmienia wartości właściwości wewnętrznych.
2. Można używać tylko na 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 Modyfikacja struktury w funkcji

Możesz oznaczyć parametr funkcji (który jest struct) jako inout

Ponieważ structtyp wartości jest przekazywany przez wartość, ponieważ funkcja wyniku pobierze kopię. Jeśli zaznaczysz structjako inoutparametr, oznacza to, że ten parametr staje się vari możesz zmienić stan, structa zmiany te będą widoczne poza zakresem funkcji

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

Używaj, letkiedy tylko możesz. Użyj, varkiedy musisz.

Jeszcze jedna różnica, z którą spotkałem się w innych językach dla Constants: nie można zainicjować stałej (let) na później , należy ją zainicjować, gdy masz zamiar zadeklarować stałą.

Na przykład :

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

Zmienna

var variableValue : Int // No issues 

letsłuży do deklarowania stałej wartości - nie zmienisz jej po nadaniu jej wartości początkowej.
varsłuży do deklarowania wartości zmiennej - możesz zmienić jej wartość, jak chcesz.

let służy do definiowania stałych, a var do definiowania zmiennych. Zdefiniujesz ciąg za pomocą var, a następnie określony ciąg można zmodyfikować (lub zmutować), przypisując go do zmiennej (w którym to przypadku można go zmodyfikować), a jeśli zdefiniujesz ciąg za pomocą niech jego stała (w takim przypadku nie może być zmodyfikowany):

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

Niech słowo kluczowe definiuje stałą

let myNum = 7

więc myNum nie może być później zmieniony;

Ale var definiuje zwykłą zmienną.

Wartość stałej nie musi być znana w czasie kompilacji, ale musisz przypisać jej wartość dokładnie raz.

Możesz używać prawie dowolnego znaku, który ci się podoba, dla nazw stałych i zmiennych, w tym znaków Unicode;

na przykład

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

Ale jeśli weźmiemy to ...

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

Jak powiedzieli Luc-Oliver, NullData i kilku innych, letdefiniuje dane niezmienne, a vardane zmienne. Wszelkie, funcktóre można wywołać na oznaczonej zmiennej, mutatingmożna wywołać tylko wtedy, gdy jest ona varzmienną (kompilator wyrzuci błąd). Dotyczy to także functych, które przyjmują inoutzmienną.

Jednak leti varrównież oznaczać, że zmienna nie może być przeniesiony. Ma dwa znaczenia, oba o bardzo podobnych celach

Wartość var można zmienić po inicjalizacji. Ale niech wartość nie ulegnie zmianie, gdy zostanie raz zilustrowana.

W przypadku var

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

W przypadku let

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

Słowo kluczowe var służy do definiowania zmiennej, której wartość można łatwo zmienić w następujący sposób:

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

Jednak słowo kluczowe let służy tylko do utworzenia stałej używanej, gdy nie chcesz ponownie zmieniać wartości stałej. Jeśli spróbujesz zmienić wartość stałej, pojawi się błąd:

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

Niech jest niezmienną zmienną, co oznacza, że ​​nie można jej zmienić, inne języki nazywają to stałą. W C ++ można go zdefiniować jako const.

Var jest zmienną zmienną, co oznacza, że ​​można ją zmienić. W C ++ (aktualizacja wersji z 2011 r.) Jest to to samo, co używanie auto, chociaż swift pozwala na większą elastyczność w użyciu. Jest to bardziej znany typ zmiennej dla początkujących.

let jest wartością stałą, więc nigdy nie można jej zmienić.

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

Var jest zmienną i może się zmieniać (ale po zdefiniowaniu nie należy do innego typu danych).

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

Jeśli spróbujesz zmienić zmienną na inny typ danych, to nie zadziała

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

Główną różnicą jest to, że varwartość zmiennej może się zmieniać, a letnie może. Jeśli chcesz mieć dane wejściowe użytkownika, możesz użyć vartej wartości, aby zmienić wartość, i użyć letzmiennej typu danych, aby wartość nie mogła zostać zmieniona.

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

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

Wartość można przypisać ponownie w przypadku var

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

** Stała newAge nie może być ponownie przypisana do nowej wartości. Próba zrobienia tego spowoduje błąd czasu kompilacji **

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

„Użyj let, aby utworzyć stałą, a var, aby utworzyć zmienną”

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

var jest zmienną, którą można zmieniać tyle razy, ile chcesz i kiedykolwiek

na przykład

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

let jest stały, którego nie można zmienić

na przykład

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

Chociaż masz już wiele różnic między let i var, ale jedna główna różnica to:

let is compiled fast in comparison to var.

Wszyscy prawie na to odpowiedzieli, ale oto sposób, w jaki możesz zapamiętać, co jest

Powiedzmy zawsze to samo, myśląc o „let”, jak to działa raz i zawsze tak, jak dla zmiennej „var” zawsze można zmienić, stąd nazywamy ją

varjest jedynym sposobem szybkiego tworzenia zmiennych. varnie oznacza zmiennej dynamicznej, jak w przypadku języków interpretowanych, takich jak javascript. Na przykład,

var name = "Bob"

W takim przypadku typ zmiennej namejest wywnioskowany, że nazwa jest typu String, możemy również tworzyć zmienne poprzez jawne zdefiniowanie typu, na przykład

var age:Int = 20

Teraz, jeśli przypiszesz ciąg do wieku, kompilator wyświetli błąd.

letsłuży do deklarowania stałych. Na przykład

let city = "Kathmandu"

Lub możemy też zrobić,

let city:String = "Kathmandu"

Próba zmiany wartości miasta powoduje błąd w czasie kompilacji.

let jest używany dla stałych, których nie można modyfikować, podczas gdy var jest zwykłą zmienną

Przykład:

let name = „Bob” Coś w stylu name = „Jim” zgłosi błąd, ponieważ stałej nie można modyfikować.

PROSTA RÓŻNICA

let = (nie można zmienić)

var = (dowolna aktualizacja czasu)

Źródło: https://thenucleargeeks.com/2019/04/10/swift-let-vs-var/

Kiedy deklarujesz zmienną za pomocą var, oznacza to, że może być aktualizowana, jest zmienna, jej wartość może być modyfikowana.

Kiedy deklarujesz zmienną za pomocą let, oznacza to, że nie można jej zaktualizować, nie jest zmienna, jej wartość nie może być modyfikowana.

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"

Rozumiemy powyższy przykład: Stworzyliśmy nową zmienną „a” ze słowem „var słowo kluczowe” i przypisaliśmy wartość „1”. Kiedy wypisuję „a”, otrzymuję wynik jako 1. Następnie przypisuję 2 do „var a”, tj. Modyfikuję wartość zmiennej „a”. Mogę to zrobić bez błędu kompilatora, ponieważ zadeklarowałem go jako var.

W drugim scenariuszu utworzyłem nową zmienną „b” ze słowem „let keyword” i przypisałem wartość „4”. Kiedy drukuję „b”, mam 4 jako wyjście. Następnie próbuję przypisać 5 do „let b”, tj. Próbuję zmodyfikować zmienną „let” i pojawia się błąd czasu kompilacji „Nie można przypisać do wartości:„ b ”jest stałą„ let ”.

Chociaż obecnie wciąż czytam instrukcję, ale myślę, że jest to bardzo zbliżone do constwskaźnika C / C ++ . Innymi słowy, coś w rodzaju różnicy między char const*i char*. Kompilator odmawia także aktualizacji treści, a nie tylko zmiany przypisania (wskaźnika).

Załóżmy na przykład, że masz taką strukturę. Uważaj, aby to była struktura, a nie klasa. AFAIK, klasy nie mają pojęcia niezmiennego stanu.

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

Ponieważ struktury są domyślnie niezmienne, musisz oznaczyć metodę mutatora za pomocą mutating. A ponieważ nazwa aaa1jest stała, nie można wywołać żadnej metody mutatora. Dokładnie tego się spodziewaliśmy na wskaźnikach C / C ++.

Uważam, że jest to mechanizm wspierający coś w rodzaju stałej poprawności .

Deklaruj stałe za pomocą słowa kluczowego let i zmienne za pomocą słowa kluczowego var.

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

Zadeklaruj wiele stałych lub wielu zmiennych w jednym wierszu, oddzielając je przecinkami:

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

Drukowanie stałych i zmiennych

Możesz wydrukować bieżącą wartość stałej lub zmiennej za pomocą funkcji println:

println(friendlyWelcome)

Swift używa interpolacji ciągów, aby dołączyć nazwę stałej lub zmiennej jako symbol zastępczy w dłuższym ciągu

Zawinąć nazwę w nawiasach i uciec przed odwrotnym ukośnikiem:

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

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

Znalazłem dobrą odpowiedź, mam nadzieję, że może pomóc :)