Was ist der Unterschied zwischen "let" und "var" in Swift?

Was ist der Unterschied zwischen letund varin Apples Swift-Sprache?

Nach meinem Verständnis handelt es sich um eine kompilierte Sprache, die den Typ jedoch zur Kompilierungszeit nicht überprüft. Es macht mich verwirrt. Woher weiß der Compiler über den Typfehler Bescheid? Wenn der Compiler den Typ nicht überprüft, liegt dann kein Problem mit der Produktionsumgebung vor?

Das letSchlüsselwort definiert eine Konstante:

let theAnswer = 42

Das theAnswerkann danach nicht mehr geändert werden. Aus diesem Grund weakkann nichts mit geschrieben werdenlet . Sie müssen Laufzeit ändern und müssen varstattdessen verwendet werden.

Das vardefiniert eine gewöhnliche Variable.

Was ist interessant:

Der Wert einer Konstante muss zur Kompilierungszeit nicht bekannt sein , aber Sie müssen den Wert genau einmal zuweisen.

Ein weiteres merkwürdiges Merkmal:

Sie können fast jedes beliebige Zeichen für Konstanten- und Variablennamen verwenden, einschließlich Unicode-Zeichen:

let 🐶🐮 = "dogcow"

Auszüge aus: Apple Inc. "The Swift Programming Language". iBooks.https://itunes.apple.com/WebObjects/MZStore.woa/wa/viewBook?id=881256329

BEARBEITEN

Weil Kommentare, die darum bitten, der Antwort weitere Fakten hinzuzufügen, diese in eine Community-Wiki-Antwort konvertieren . Fühlen Sie sich frei, die Antwort zu bearbeiten, um sie besser zu machen.

Laut dem Swift Programming Language Book

Wie C verwendet Swift Variablen, um Werte mit einem identifizierenden Namen zu speichern und auf diese zu verweisen . Swift verwendet auch in großem Umfang Variablen, deren Werte nicht geändert werden können. Diese sind als Konstanten bekannt und viel leistungsfähiger als Konstanten in C.

Beide varund letsind Referenzen , daher letist eine konstante Referenz . Die Verwendung grundlegender Typen zeigt nicht wirklich, wie letsich das von unterscheidet const. Der Unterschied ergibt sich bei der Verwendung mit Klasseninstanzen (Referenztypen):

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"

letwird verwendet, um Konstanten und varVariablen zu definieren.

Es ist vielleicht besser, diesen Unterschied durch den Begriff der Veränderbarkeit / Unveränderlichkeit zu erklären, der das richtige Paradigma für die Veränderbarkeit von Werten und Instanzen im Objektraum ist, das größer ist als die einzigen üblichen Begriffe "Konstante / Variable". Darüber hinaus kommt dies dem Ziel-C-Ansatz näher.

2 Datentypen: Werttyp und Referenztyp.

Im Kontext von Werttypen:

'let' definiert einen konstanten Wert (nicht zähmbar). 'var' definiert einen veränderbaren Wert (veränderlich).

let aInt = 1   //< aInt is not changeable

var aInt = 1   //< aInt can be changed

Im Zusammenhang mit Referenztypen:

Die Bezeichnung von Daten ist nicht der Wert, sondern der Verweis auf einen Wert.

wenn aPerson = Person (Name: Foo, zuerst: Bar)

aPerson enthält nicht die Daten dieser Person, sondern den Verweis auf die Daten dieser Person.

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)

Das

Der Abschnitt Deklarieren von Konstanten und Variablen in der Dokumentation zur Swift-Programmiersprache enthält Folgendes:

Sie deklarieren Konstanten mit dem Schlüsselwort let und Variablen mit dem Schlüsselwort var.

Stellen Sie sicher, dass Sie verstehen, wie dies für Referenztypen funktioniert. Im Gegensatz zu Werttypen können sich die zugrunde liegenden Eigenschaften des Objekts ändern, obwohl eine Instanz eines Referenztyps als Konstante deklariert wird. Weitere Informationen finden Sie im Abschnitt Klassen sind Referenztypen in der Dokumentation. Sehen Sie sich das Beispiel an, in dem sie die Eigenschaft frameRate ändern.

Sehr einfach:

• let ist konstant.
• var ist dynamisch.

Beschreibung:

letschafft eine Konstante. (irgendwie wie einNSString ). Sie können den Wert nicht mehr ändern, nachdem Sie ihn festgelegt haben. Sie können es dennoch zu anderen Dingen hinzufügen und neue Variablen erstellen.

varerstellt eine Variable. (so ähnlich NSMutableString), damit Sie den Wert ändern können. Dies wurde jedoch mehrfach beantwortet.

letdefiniert eine "Konstante". Sein Wert wird einmal und nur einmal festgelegt, jedoch nicht unbedingt, wenn Sie ihn deklarieren. Beispielsweise letdefinieren Sie eine Eigenschaft in einer Klasse, die während der Initialisierung festgelegt werden muss:

class Person {

    let firstName: String
    let lastName: String

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

Bei diesem Setup ist es ungültig, firstNameoder lastNamenach dem Aufruf (z. B.) Person(first:"Malcolm", last:"Reynolds")eine PersonInstanz zu erstellen .

Sie müssen zum Zeitpunkt der Kompilierung einen Typ für alle Variablen ( letoder var) definieren , und jeder Code, der versucht, eine Variable festzulegen , verwendet möglicherweise nur diesen Typ (oder einen Subtyp). Sie können zur Laufzeit einen Wert zuweisen , dessen Typ jedoch zur Kompilierungszeit bekannt sein muss.

let- constant
var-variable

[Konstante gegen Variable]
[Struktur gegen Klasse]

Offizielle doc docs.swift.org sagt

Der Wert von a constantkann nicht geändert werden, sobald er festgelegt wurde, während a variablein Zukunft auf einen anderen Wert festgelegt werden kann.

Diese Terminologie beschreibt eigentlich eine Umhängen Mechanismus

Veränderbarkeit - veränderbar - Der Status des Objekts kann nach der Erstellung geändert werden

Wert und Referenztyp ^[Info]

Wert (Struktur, Aufzählung)

Swifts structkönnen ihren Veränderbarkeitsstatus ändern:

let+ struct= immutable= Wertekonstante
Sie kann nicht neu zugewiesen oder geändert werden

var+ struct= mutable
Es kann neu zugewiesen oder geändert werden

Referenztyp (Klasse)

Swifts classessind mutableein Priorat

let+ class= Adresskonstante
Sie kann nicht neu zugewiesen und geändert werden

var+ class
Es kann neu zugewiesen oder geändert werden

//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 - Funktionen von Mutating Struct

Sie können die Methode einer Struktur als markierenmutating

1. Gibt an, dass diese Funktion interne Eigenschaftswerte ändert.
2. Kann nur auf var+ verwendet werdenstruct

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 Struktur innerhalb einer Funktion ändern

Sie können den Parameter einer Funktion (der struct ist) als markieren inout

Da structein Werttyp als Wert übergeben wird, ruft die Ergebnisfunktion eine Kopie ab. Wenn Sie einen structals inoutParameter markieren , bedeutet dies, dass dieser Parameter wird varund Sie einen Status von ändern können structund diese Änderungen außerhalb des Funktionsumfangs sichtbar sind

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

Verwenden letSie, wann immer Sie können. Verwenden varSie, wenn Sie müssen.

Ein weiterer Unterschied, den ich in anderen Sprachen für Konstanten festgestellt habe, ist: Ich kann die Konstante nicht für später initialisieren (let) , sollte initialisiert werden, wenn Sie die Konstante deklarieren möchten.

Zum Beispiel :

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

Variable

var variableValue : Int // No issues 

letwird verwendet, um einen konstanten Wert zu deklarieren - Sie werden ihn nicht ändern, nachdem Sie ihm einen Anfangswert gegeben haben.
varwird verwendet, um einen variablen Wert zu deklarieren - Sie können seinen Wert nach Belieben ändern.

let wird verwendet, um Konstanten zu definieren, und var , um Variablen zu definieren. Sie definieren die Zeichenfolge mit var, dann kann eine bestimmteZeichenfolgegeändert (oder mutiert) werden, indem Sie sie einer Variablen zuweisen (in diesem Fall kann sie geändert werden). Wenn Sie die Zeichenfolge mit let definieren , ist sie eine Konstante (in diesem Fall kann sie nicht sein) geändert):

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

Das Schlüsselwort let definiert eine Konstante

let myNum = 7

Daher kann myNum danach nicht mehr geändert werden.

Aber var definiert eine gewöhnliche Variable.

Der Wert einer Konstante muss zur Kompilierungszeit nicht bekannt sein, aber Sie müssen ihr genau einmal einen Wert zuweisen.

Sie können fast jedes beliebige Zeichen für Konstanten- und Variablennamen verwenden, einschließlich Unicode-Zeichen.

z.B

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

Aber wenn wir nehmen dann ...

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

Wie Luc-Oliver definieren NullData und einige andere hier letunveränderliche Daten, während sie varveränderbare Daten definieren. Alle Elemente func, die für die markierte Variable aufgerufen werden können, mutatingkönnen nur aufgerufen werden, wenn es sich um eine varVariable handelt (der Compiler gibt einen Fehler aus). das gilt auch fürfunc 's, die eine inoutVariable aufnehmen.

Allerdings , letund varauch bedeuten , dass der Variable nicht neu zugeordnet werden kann. Es hat zwei Bedeutungen, beide mit sehr ähnlichen Zwecken

Der var- Wert kann nach der Initialisierung geändert werden. Aber lassen Sie den Wert nicht ändern, wenn er einmal intilisiert wird.

Im Falle von var

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

Im Falle von vermieten

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

Mit dem Schlüsselwort var wird eine Variable definiert, deren Wert Sie wie folgt leicht ändern können:

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

Das Schlüsselwort let dient jedoch nur zum Erstellen einer Konstante, die verwendet wird, wenn Sie den Wert der Konstante nicht erneut ändern möchten. Wenn Sie versuchen, den Wert der Konstante zu ändern, wird folgende Fehlermeldung angezeigt:

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 ist eine unveränderliche Variable, was bedeutet, dass sie nicht geändert werden kann. Andere Sprachen nennen dies eine Konstante. In C ++ können Sie es als const definieren.

Var ist eine veränderbare Variable, was bedeutet, dass sie geändert werden kann. In C ++ (Versionsaktualisierung 2011) entspricht dies der Verwendung von auto, obwohl swift mehr Flexibilität bei der Verwendung ermöglicht. Dies ist der bekanntere Variablentyp für Anfänger.

let ist ein konstanter Wert, daher kann er niemals geändert werden.

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

Var ist eine Variable und kann sich ändern (aber nachdem sie nicht für einen anderen Datentyp definiert wurde).

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

Wenn Sie versuchen, die Variable in einen anderen Datentyp zu ändern, funktioniert dies nicht

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

Der Hauptunterschied besteht darin, dass sich der varVariablenwert ändern kann und letnicht. Wenn Sie Benutzereingabedaten haben möchten, verwenden Sie diese, vardamit der Wert geändert werden kann, und verwenden Sie die letDatentypvariable, damit der Wert nicht geändert werden kann.

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

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

Bei var kann ein Wert neu zugewiesen werden

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

** Die newAge-Konstante kann keinem neuen Wert zugewiesen werden. Wenn Sie dies versuchen, wird ein Fehler bei der Kompilierung angezeigt **

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

"Verwenden Sie let, um eine Konstante zu erstellen, und var, um eine Variable zu erstellen."

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

var ist eine Variable, die beliebig oft und jederzeit geändert werden kann

zum Beispiel

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

Lassen ist eine Konstante, die nicht geändert werden kann

zum Beispiel

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

Obwohl Sie bereits viele Unterschiede zwischen let und var haben, ist ein Hauptunterschied:

let is compiled fast in comparison to var.

Jeder hat so ziemlich darauf geantwortet, aber hier ist eine Möglichkeit, sich daran zu erinnern, was was ist

Lassen Sie uns immer den gleichen Gedanken an "let" sagen, wie dies einmal funktionieren soll, und immer, wenn sich "var" -Variablen ändern können, werden sie daher als Variablen bezeichnet

varNur so können Sie schnell Variablen erstellen. varbedeutet nicht dynamische Variable wie im Fall von interpretierten Sprachen wie Javascript. Zum Beispiel,

var name = "Bob"

In diesem Fall wird auf den Variablentyp geschlossen name, dass der Name vom Typ Stringist. Wir können Variablen auch erstellen, indem wir beispielsweise den Typ explizit definieren

var age:Int = 20

Wenn Sie nun age eine Zeichenfolge zuweisen, gibt der Compiler den Fehler aus.

letwird verwendet, um Konstanten zu deklarieren. Zum Beispiel

let city = "Kathmandu"

Oder wir können auch tun,

let city:String = "Kathmandu"

Wenn Sie versuchen, den Wert von city zu ändern, tritt beim Kompilieren ein Fehler auf.

let wird für Konstanten verwendet, die nicht geändert werden können, während var eine gewöhnliche Variable ist

Beispiel:

let name = "Bob" So etwas wie name = "Jim" löst einen Fehler aus, da eine Konstante nicht geändert werden kann.

EINFACHER UNTERSCHIED

let = (kann nicht geändert werden)

var = (jederzeit aktualisiert)

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

Wenn Sie eine Variable mit var deklarieren, bedeutet dies, dass sie aktualisiert werden kann, dass sie variabel ist und dass ihr Wert geändert werden kann.

Wenn Sie eine Variable mit let deklarieren, bedeutet dies, dass sie nicht aktualisiert werden kann, nicht variabel ist und dass ihr Wert nicht geändert werden kann.

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"

Lassen Sie uns das obige Beispiel verstehen: Wir haben eine neue Variable "a" mit dem Schlüsselwort "var" erstellt und den Wert "1" zugewiesen. Wenn ich "a" drucke, erhalte ich die Ausgabe als 1. Dann weise ich "var a" 2 zu, dh ich ändere den Wert der Variablen "a". Ich kann es tun, ohne einen Compilerfehler zu bekommen, weil ich es als var deklariert habe.

Im zweiten Szenario habe ich eine neue Variable "b" mit dem Schlüsselwort "let" erstellt und den Wert "4" zugewiesen. Wenn ich "b" drucke, bekomme ich 4 als Ausgabe. Dann versuche ich, "let b" 5 zuzuweisen, dh ich versuche, die Variable "let" zu ändern, und ich erhalte den Fehler "Kompilierungszeit kann nicht dem Wert zugewiesen werden: 'b' ist eine 'let'-Konstante".

Derzeit lese ich zwar noch das Handbuch, aber ich denke, dies kommt dem C / C ++ - constZeiger sehr nahe . Mit anderen Worten, so etwas wie ein Unterschied zwischen char const*und char*. Der Compiler weigert sich auch, Inhalte zu aktualisieren, nicht nur die Neuzuweisung von Referenzen (Zeiger).

Angenommen, Sie haben diese Struktur. Achten Sie darauf, dass dies eine Struktur ist, keine Klasse. AFAIK, Klassen haben kein Konzept von unveränderlichem Zustand.

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

Da die Strukturen standardmäßig unveränderlich sind, müssen Sie eine Mutatormethode mit markieren mutating. Und weil der Name aaa1konstant ist, können Sie keine Mutator-Methode dafür aufrufen. Dies ist genau das, was wir von C / C ++ - Zeigern erwartet haben.

Ich glaube, dies ist ein Mechanismus, um eine Art Konstanzkorrektheit zu unterstützen .

Deklarieren Sie Konstanten mit dem Schlüsselwort let und Variablen mit dem Schlüsselwort var.

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

Deklarieren Sie mehrere Konstanten oder mehrere Variablen in einer einzelnen Zeile, die durch Kommas getrennt sind:

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

Konstanten und Variablen drucken

Sie können den aktuellen Wert einer Konstanten oder Variablen mit der Funktion println drucken:

println(friendlyWelcome)

Swift verwendet die Zeichenfolgeninterpolation, um den Namen einer Konstanten oder Variablen als Platzhalter in eine längere Zeichenfolge aufzunehmen

Wickeln Sie den Namen in Klammern und schließen Sie ihn mit einem Backslash vor der öffnenden Klammer an:

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

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

Habe eine gute Antwort gefunden, hoffe es kann helfen :)