web-dev-qa-db-fra.com

Quelle est la différence entre `let` et` var` dans swift?

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?

swift
275
Edward

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

MODIFIER

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.

374
jm666

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"
32
Krzak

let est utilisé pour définir des constantes et var pour définir des variables.

14
atxe

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.

7
svmrajesh

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.

6
mr_sd

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)
5
Luc-Olivier

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.

4
rickster

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.

2
jabez128

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
2
Kumar KL

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();
1
Abhishek

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

1
matrinox

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
1
Daxesh Nagar

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
1
subash chandru

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.

1
HS__HS

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
1
Aryan C

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.
0
Vivek Tyagi

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.
0
Mario Jimenez

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.

0
Manoj Karki

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.

0
alex2792

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 ».

0
A H M

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
0
Mohit tomar

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.
0
Debasis Das

DIFFÉRENCE SIMPLE

let = (ne peut pas être changé)

var = (toute mise à jour de l'heure)

0
hamayun zeb

Dans Swiftletest une propriété en lecture seule et est accessible uniquement par un getter.letest une variable immuable.

let exemple:

let goldenRatio: Double = 1.6180339 {
    get { return field }
}

Cependant,varest une propriété read-and-write , de sorte que vous pouvez y accéder non seulement par un getter mais également par un setter.varest mutable.

var exemple:

var voltage: Int = 110 {
    get { 
        return field 
    }
    set(value) { 
        field = value 
    }
}

Si vous essayez de changer une let immuable, Xcode vous montrera une erreur:

func changerOfTheValue() {  
    goldenRatio = 1.62        // ERROR
    print(goldenRatio)
}

// RESULT:  "let" cannot be reassigned

Mais une variable var peut être facilement modifiée:

func changerOfTheValue() {  
    voltage = 220
    print(voltage)
}

// RESULT:  220

J'espère que cela t'aides.

0
ARGeo

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 !
0
Greg Development

“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

0
zumzum

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 

0
allen6131

Dans Swift, nous avons deux types de variables

  1. var
  2. laisser

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
0
Sardor Islomov