Quelle est la différence entre let
et var
dans la langue Swift d'Apple?
À mon sens, il s’agit d’un langage compilé, mais il ne vérifie pas le type lors de la compilation. Cela me rend confus. Comment le compilateur sait-il l'erreur de type? Si le compilateur ne vérifie pas le type, n'est-ce pas un problème avec l'environnement de production?
Le mot clé let
définit une constante:
let theAnswer = 42
La theAnswer
ne peut pas être modifiée par la suite. C'est pourquoi rien weak
ne peut être écrit avec let
. Ils ont besoin de changer pendant l'exécution et vous devez plutôt utiliser var
.
La var
définit une variable ordinaire.
Ce qui est intéressant:
La valeur d’une constante n’a pas besoin d’être connue au moment de la compilation, mais vous devez l’attribuer exactement une fois.
Une autre caractéristique étrange:
Vous pouvez utiliser presque tous les caractères que vous aimez pour constante et variable Noms, y compris les caractères Unicode:
let ???????? = "dogcow"
Extraits de: Apple Inc. «Le langage de programmation Swift.» IBooks. https://iTunes.Apple.com/WebObjects/MZStore.woa/wa/viewBook?id=881256329
Parce que les commentaires demandant d'ajouter d'autres faits à la réponse, convertissons cela en community wiki answer . N'hésitez pas à modifier la réponse pour l'améliorer.
Selon Le livre de langage de programmation Swift
Comme C, Swift utilise des variables pour stocker et renvoie à des valeurs par un nom identifiant. Swift utilise aussi beaucoup les variables dont les valeurs ne peuvent pas être changées. Celles-ci sont appelées constantes et sont beaucoup plus puissant que les constantes en C.
var
et let
sont tous deux references, donc let
est une référence const . L'utilisation de types fondamentaux n'indique pas vraiment en quoi let
est différent de const
. La différence vient de son utilisation avec instances de classe (types de référence):
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
est utilisé pour définir des constantes et var
pour définir des variables.
Très simple:
let
est constant. var
est dynamique.Bit de description:
let
crée une constante. (un peu comme un NSString
). Vous ne pouvez pas changer sa valeur une fois que vous l'avez définie. Vous pouvez toujours l'ajouter à d'autres choses et créer de nouvelles variables.
var
crée une variable. (un peu comme NSMutableString
) afin que vous puissiez en changer la valeur. Mais cela a été répondu à plusieurs reprises.
Le
Déclaration de constantes et de variables section de la documentation de Swift Programming Language spécifie ce qui suit:
Vous déclarez des constantes avec le mot-clé let et des variables avec le mot-clé var.
Assurez-vous de comprendre comment cela fonctionne pour les types de référence. Contrairement aux types de valeur, les propriétés sous-jacentes de l'objet peuvent changer même si une instance d'un type de référence est déclarée comme constante. Voir la section Les classes sont des types de référence de la documentation et examinez l'exemple dans lequel elles modifient la propriété frameRate.
Il est peut-être préférable d’énoncer cette différence par la notion de mutabilité/immuabilité qui est le paradigme correct de la possibilité de changer les valeurs et les instances dans l’espace Objects qui est plus grande que les seules notions habituelles de "constante/variable" . Approche C.
2 types de données: type de valeur et type de référence.
Dans le contexte des types de valeur:
'let' définit une valeur constante (indomptable). 'var' définit une valeur modifiable (mutable).
let aInt = 1 //< aInt is not changeable
var aInt = 1 //< aInt can be changed
Dans le contexte des types de référence:
L'étiquette d'une donnée n'est pas la valeur mais la référence à une valeur.
si aPerson = Person (nom: Foo, premier: Bar)
aPerson ne contient pas les données de cette personne, mais la référence aux données de cette personne.
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
définit une "constante". Sa valeur est définie une et une seule fois, mais pas nécessairement lorsque vous la déclarez. Par exemple, vous utilisez let
pour définir une propriété dans une classe qui doit être définie lors de l'initialisation:
class Person {
let firstName: String
let lastName: String
init(first: String, last: String) {
firstName = first
lastName = last
super.init()
}
}
Avec cette configuration, il n'est pas valide d'affecter à firstName
ou lastName
après avoir appelé (par exemple) Person(first:"Malcolm", last:"Reynolds")
pour créer une instance Person
.
Vous devez définir un type pour toutes les variables (let
ou var
) au moment de la compilation, et tout code qui tente de définir une variable peut uniquement utiliser ce type (ou un sous-type). Vous pouvez affecter un value au moment de l'exécution, mais son type doit être connu au moment de la compilation.
let
est utilisé pour déclarer une valeur constante, ce qui signifie que vous ne la modifierez pas après lui avoir attribué une valeur initiale.var
sert à décaler une valeur de variable, ce qui signifie que vous pouvez la modifier à votre guise.
Une différence supplémentaire, que j’ai rencontrée dans d’autres langues pour Constants, est la suivante:ne peut initialiser la constante (let) pour plus tard, devrait être initialisé au moment où vous déclarez la constante.
Par exemple :
let constantValue : Int // Compile error - let declarations require an initialiser expression
Variable
var variableValue : Int // No issues
var la valeur peut être changée après l'initialisation. Mais let value ne change pas, quand il est intilize une fois.
En cas de var
function variable() {
var number = 5, number = 6;
console.log(number); // return console value is 6
}
variable();
En cas de location
function abc() {
let number = 5, number = 6;
console.log(number); // TypeError: redeclaration of let number
}
abc();
Comme Luc-Oliver, NullData et quelques autres l'ont dit ici, let
définit des données immuables, tandis que var
définit des données mutables. Tout func
pouvant être appelé sur la variable marquée mutating
ne peut être appelé que s'il s'agit d'une variable var
(le compilateur générera une erreur). Ceci s'applique également aux func
qui prennent une variable inout
.
Cependant, let
et var
signifient également que la variable ne peut pas être réaffectée. Il a deux sens, les deux ayant des objectifs très similaires
letest utilisé pour définir les constantes etvarpour définir les variables . Vous définissez la chaîne à l'aide devaralors une chaîne particulière peut être modifié (ou muté) en l'attribuant à une variable (dans ce cas, il peut être modifié), et si vous définissez la chaîne à l'aide deletune constante (dans ce cas, elle ne peut pas être modifiée):
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 est une variable qui peut être modifiée autant de fois que vous le souhaitez
par exemple
var changeit:Int=1
changeit=2
//changeit has changed to 2
let est une constante qui ne peut pas être changée
par exemple
let changeit:Int=1
changeit=2
//Error becuase constant cannot be changed
Let est une variable immuable, ce qui signifie qu’elle ne peut pas être modifiée, d’autres langues appellent cela une constante. En C++, vous pouvez le définir en tant que const.
Var est une variable mutable, ce qui signifie qu'elle peut être modifiée. En C++ (mise à jour 2011), cela revient à utiliser auto, bien que Swift permette une plus grande souplesse d'utilisation. C'est le type de variable le plus connu des débutants.
Le mot clé var est utilisé pour définir une variable dont vous pouvez facilement modifier la valeur comme suit:
var no1 = 1 // declaring the variable
no1 = 2 // changing the value since it is defined as a variable not a constant
Toutefois, le mot-clé let sert uniquement à créer une constante utilisée lorsque vous ne souhaitez pas modifier à nouveau la valeur de la constante. Si vous essayez de changer la valeur de la constante, vous obtiendrez une erreur:
let no2 = 5 // declaring no2 as a constant
no2 = 8 // this will give an error as you cannot change the value of a constant
Même si vous avez déjà beaucoup de différence entre let et var, mais une différence principale est:
let is compiled fast in comparison to var.
let est une valeur constante, elle ne peut donc jamais être modifiée.
let number = 5
number = 6 //This will not compile.
Var est une variable, et peut changer (mais après, il n'est pas défini sur un type de données différent.)
var number = 5
number = 6 //This will compile.
Si vous essayez de remplacer la variable par un type de données différent, cela ne fonctionnera pas.
var number = 5
number = "Hello World" //This will not compile.
var
est le seul moyen de créer une variable dans Swift. var
ne signifie pas variable dynamique comme dans le cas de langages interprétés tels que javascript. Par exemple,
var name = "Bob"
Dans ce cas, le type de variable name
est déduit que le nom est de type String
, nous pouvons également créer des variables en définissant explicitement le type, par exemple
var age:Int = 20
Maintenant, si vous assignez une chaîne à age, le compilateur donne l'erreur.
let
est utilisé pour déclarer des constantes. Par exemple
let city = "Kathmandu"
Ou on peut aussi faire,
let city:String = "Kathmandu"
Si vous essayez de changer la valeur de city, cela produira une erreur lors de la compilation.
let est utilisé pour les constantes qui ne peuvent pas être modifiées alors que var est une variable ordinaire
Exemple:
let name = “Bob” Quelque chose comme name = “Jim” jettera une erreur car une constante ne peut pas être modifiée.
Source: https://thenucleargeeks.com/2019/04/10/Swift-let-vs-var/
Lorsque vous déclarez une variable avec var, cela signifie qu’elle peut être mise à jour, qu’elle est variable et que sa valeur peut être modifiée.
Lorsque vous déclarez une variable avec let, cela signifie qu’elle ne peut pas être mise à jour, c’est une variable non variable, sa valeur ne peut pas être modifiée.
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"
Comprenons l'exemple ci-dessus: Nous avons créé une nouvelle variable “a” avec “mot-clé var” et attribué la valeur “1”. Lorsque j’imprime “a”, la sortie est égale à 1. Ensuite, j’affecte 2 à “var a”, c’est-à-dire que je modifie la valeur de la variable “a”. Je peux le faire sans obtenir d'erreur de compilation parce que je l'ai déclaré en tant que var.
Dans le deuxième scénario, j'ai créé une nouvelle variable “b” avec “let keyword” et attribué la valeur “4”. Quand j’imprime «b», j’en ai 4 en sortie. Ensuite, j’essaie d’attribuer 5 à «let b», c’est-à-dire que j’essaie de modifier la variable «let» et que l’erreur de compilation s’affiche: «Impossible d’attribuer à la valeur:« b »est une constante« let ».
let mot-clé définit une constante
let myNum = 7
donc mon Nom ne peut pas être changé après;
Mais var définit une variable ordinaire.
La valeur d’une constante n’a pas besoin d’être connue au moment de la compilation, mais vous devez lui attribuer une valeur exactement une fois.
Vous pouvez utiliser presque tous les caractères de votre choix pour les noms de variables et de constantes, y compris les caractères Unicode.
par exemple.
var x = 7 // here x is instantiated with 7
x = 99 // now x is 99 it means it has been changed.
Mais si nous prenons, alors ...
let x = 7 // here also x is instantiated with 7
x = 99 // this will a compile time error
Une valeur peut être réaffectée en cas de var
//Variables
var age = 42
println(age) //Will print 42
age = 90
println(age) //Will Print 90
** la constante newAge ne peut pas être réaffectée à une nouvelle valeur. Essayer de le faire donnera une erreur de compilation **
//Constants
let newAge = 92 //Declaring a constant using let
println(newAge) //Will print 92.
DIFFÉRENCE SIMPLE
let = (ne peut pas être changé)
var = (toute mise à jour de l'heure)
Dans Swift
let
est une propriété en lecture seule et est accessible uniquement par un getter.let
est une variable immuable.
let
exemple:let goldenRatio: Double = 1.6180339 {
get { return field }
}
Cependant,
var
est une propriété read-and-write , de sorte que vous pouvez y accéder non seulement par un getter mais également par un setter.var
est mutable.
var
exemple:var voltage: Int = 110 {
get {
return field
}
set(value) {
field = value
}
}
let
immuable, Xcode vous montrera une erreur:func changerOfTheValue() {
goldenRatio = 1.62 // ERROR
print(goldenRatio)
}
// RESULT: "let" cannot be reassigned
var
peut être facilement modifiée:func changerOfTheValue() {
voltage = 220
print(voltage)
}
// RESULT: 220
J'espère que cela t'aides.
La principale différence est que la valeur de la variable var
peut changer, et que let
ne le peut pas. Si vous souhaitez que les données utilisateur soient entrées, vous devez utiliser var
pour pouvoir modifier la valeur et utiliser la variable let
pour que la valeur ne puisse pas être modifiée.
var str = "dog" // str value is "dog"
str = "cat" // str value is now "cat"
let strAnimal = "dog" // strAnimal value is "dog"
strAnimal = "cat" // Error !
“Utilisez let pour créer une constante et var pour créer une variable”
Excerpt From: Apple Inc. “The Swift Programming Language.” iBooks.
https://itun.es/us/jEUH0.l
Tout le monde a à peu près répondu à cela, mais voici un moyen de vous rappeler ce qu’est ce
Laissons toujours la même pensée de "let" en laissant cela fonctionner pour une fois et toujours comme pour les variables "var" peuvent toujours changer, elles sont donc appelées variables
Dans Swift, nous avons deux types de variables
ces deux tâches sont identiques et contiennent des objets (valeur de copie, valeur de référence, etc.).
Dans var variable, je peux changer d'objet contenant en un autre pendant l'exécution du programme
var x = 12
x = 13 // it is Ok
Dans let variable, je ne peux pas changer d’objet contenant en un autre pendant l’exécution du programme mais je dois l’initialiser en premier.
let x = 12
x = 13 // it is not OK , it will generate error